home *** CD-ROM | disk | FTP | other *** search
/ Tech Arsenal 1 / Tech Arsenal (Arsenal Computer).ISO / tek-01 / pcrob13.zip / EXAMPLES / EXPLORER.CPP < prev    next >
C/C++ Source or Header  |  1992-10-29  |  3KB  |  210 lines
  1. #include <conio.h>
  2. #include <dos.h>
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <time.h>
  6.  
  7. #include "pcrobots.h"
  8.  
  9. const char pattern[5]={17,10,4,10,17};
  10. typedef unsigned char byte;
  11.  
  12. struct     {
  13.      int    x,
  14.         y,
  15.         angle,
  16.         next;
  17.     }
  18.     angle[4]={{1,0,0,1},{0,1,90,2},{-1,0,180,3},{0,-1,270,0}};
  19.  
  20. byte map[100][100];
  21. int    x_pos,
  22.     y_pos;
  23.  
  24. struct    POINT
  25.     {
  26.      int x,y;
  27.     };
  28.  
  29. POINT    target;
  30. POINT    last_map;
  31.  
  32.  
  33. char    local_map[81];
  34.  
  35. POINT      refueler[10];
  36. int    num_refuelers=0;
  37.  
  38. struct    {
  39.      POINT     pos;
  40.      int    link;
  41.     }
  42.     transport[20];
  43.  
  44. int    num_transports=0;
  45.  
  46. int    old_batt;
  47.  
  48. int    go_dir=0,
  49.     last_dir=0;
  50. int    force_dir=0;
  51.  
  52. void    main(void)
  53. {
  54.  randomize();
  55.  
  56.  int target_speed=50;
  57.  target.x=100;
  58.  target.y=750;
  59.  
  60.  configure(2,4,0,2,2);
  61.  
  62.  {
  63.   for (int i=0;i<100;i++)
  64.   {
  65.    for (int j=0;j<100;j++)
  66.    {
  67.     map[i][j]=255;
  68.    }
  69.   }
  70.  }
  71.  
  72. // target.x=-1;
  73.  getxy(&last_map.x,&last_map.y);
  74.  
  75.  while(1)
  76.  {
  77.   getxy(&x_pos,&y_pos);
  78.   int x_square=x_pos/10;
  79.   int y_square=y_pos/10;
  80.   if ((((x_pos-last_map.x)*(x_pos-last_map.x))+
  81.        ((y_pos-last_map.y)*(y_pos-last_map.y))>400)
  82.      ||(map[y_square][x_square]==255))
  83.   {
  84.    get_local_map(local_map);
  85.    last_map.x=x_pos;
  86.    last_map.y=y_pos;
  87.    char *ptr=local_map;
  88.    int     x=x_square-4,
  89.     y=y_square-4;
  90.    for (int i=0;i<9;i++)
  91.    {
  92.     for (int j=0;j<9;j++)
  93.     {
  94.      if ((x<0)||(x>=100)||(y<0)||(y>=100))
  95.       ptr++;
  96.      else
  97.      {
  98.       int val=*(ptr++);
  99.       map[y][x]=val;
  100.       switch(val)
  101.       {
  102.        case ARENA_REFUEL:{
  103.               int found=-1;
  104.               for (int i=0;i<num_refuelers;i++)
  105.               {
  106.                if ((refueler[i].x==x)&&(refueler[i].y==y))
  107.                {
  108.                 found=i;
  109.                 break;
  110.                }
  111.               }
  112.               if (found==-1)
  113.               {
  114.                refueler[num_refuelers].x=x;
  115.                refueler[num_refuelers].y=y;
  116.                target.x=x*10+5;
  117.                target.y=y*10+5;
  118.                num_refuelers++;
  119.               }
  120.              }
  121.              break;
  122.       }
  123.      }
  124.      x++;
  125.     }
  126.     y++;
  127.     x-=9;
  128.    }
  129.   }
  130.   if (target.x==-1)
  131.   {
  132.    target.x=random(1000);
  133.    target.y=random(1000);
  134.    target_speed=50;
  135.   }
  136.  
  137.  
  138.   go_dir=-1;
  139.   if (x_pos<target.x)
  140.   {
  141.    go_dir=0;
  142.   }
  143.   else
  144.   {
  145.    if (x_pos>target.x)
  146.     go_dir=2;
  147.   }
  148.   if (go_dir==-1)
  149.   {
  150.    if (y_pos<target.y)
  151.    {
  152.     go_dir=1;
  153.    }
  154.    else
  155.    {
  156.     if (y_pos>target.y)
  157.      go_dir=3;
  158.    }
  159.   }
  160. /*
  161.   if (last_dir==((go_dir+2)%4))
  162.    go_dir=last_dir;
  163.   else
  164.    last_dir=go_dir;
  165. */
  166.   if (go_dir==-1)
  167.   {
  168.    go_dir=0;
  169.    last_dir=0;
  170.    if (target_speed!=0)
  171.    {
  172.     target_speed=0;
  173.     old_batt=battery()-10;
  174.    }
  175. //   target.x=-1;
  176.   }
  177.  
  178.   if (speed()+target_speed==0)
  179.   {
  180.    int newbatt=battery();
  181.    debug_flag(0,1);
  182.  
  183.    if (newbatt-old_batt<10)
  184.    {
  185.     debug_flag(1,1);
  186.     target.x=-1;
  187.    }
  188.    else
  189.    {
  190.     debug_flag(1,0);
  191.     old_batt=newbatt;
  192.    }
  193.   }
  194.   else
  195.    debug_flag(0,0);
  196.  
  197.   while ((map[y_square+angle[go_dir].y][x_square+angle[go_dir].x]==1)||
  198.      (y_square+angle[go_dir].y<0)||(y_square+angle[go_dir].y>=100)||
  199.      (x_square+angle[go_dir].x<0)||(x_square+angle[go_dir].x>=100))
  200.   {
  201.    go_dir=(angle[go_dir].next);
  202.   }
  203.  
  204.   move (target_speed,angle[go_dir].angle);
  205.  
  206.  }
  207.  
  208. }
  209.  
  210.